// 后台服务工作脚本
console.log('自动登录助手后台脚本已启动');

// 记录不同域名的最后一次登出时间
let lastSignOutTimeByDomain = {};
let signOutCooldownMs = 2; // 默认2秒冷却时间

// 存储每个tab的登录状态：{ tabId: { account: {...}, loginTime: timestamp, hostname: 'xxx' } }
const tabLoginStatus = new Map();

// 存储从localhost接口获取的全局账号列表
let globalAccountsList = null;

// 初始化时加载冷却时间设置
chrome.storage.local.get(['signOutCooldown'], function(result) {
  signOutCooldownMs = (result.signOutCooldown || 2) * 1000; // 转换为毫秒
  console.log('background加载登出冷却时间设置:', signOutCooldownMs / 1000, '秒');
});

// 如果是localhost环境，获取全局账号列表
async function fetchGlobalAccounts() {
  try {
    console.log('正在从localhost获取全局账号列表...');
    const response = await fetch('http://localhost:3700/api/global/getAllAccounts');
    if (response.ok) {
      const result = await response.json();
      if (result.success && result.data) {
        globalAccountsList = result.data;
        console.log('成功获取全局账号列表:', globalAccountsList.length, '个环境');
        
        // 将数据转换并存储到内存缓存中
        convertAndStoreGlobalAccounts(globalAccountsList);
        return Promise.resolve();
      } else {
        console.warn('获取全局账号列表失败:', result);
        return Promise.reject(new Error(result.message || '获取账号列表失败'));
      }
    } else {
      console.warn('获取全局账号列表请求失败:', response.status);
      return Promise.reject(new Error(`请求失败: ${response.status}`));
    }
  } catch (error) {
    console.log('获取全局账号列表出错 (这在非localhost环境下是正常的):', error.message);
    return Promise.reject(error);
  }
}

// 将全局账号数据存储到内存缓存中
function convertAndStoreGlobalAccounts(accountsData) {
  // 直接存储到内存变量中，不使用chrome.storage
  globalAccountsList = accountsData;
  console.log('全局账号列表已缓存到内存:', accountsData.length, '个环境');
}

// 初始化时检查是否是localhost环境并获取全局账号
chrome.tabs.query({}, function(tabs) {
  const hasLocalhost = tabs.some(tab => tab.url && tab.url.includes('localhost'));
  if (hasLocalhost) {
    console.log('检测到localhost环境，获取全局账号列表');
    fetchGlobalAccounts().catch(error => {
      console.log('初始化获取全局账号失败:', error.message);
    });
  }
});

// 监听新标签页创建，如果是localhost页面也获取全局账号
chrome.tabs.onCreated.addListener(function(tab) {
  if (tab.url && tab.url.includes('localhost')) {
    console.log('新建localhost标签页，获取全局账号列表');
    // 稍微延迟一下确保页面加载
    setTimeout(() => {
      if (!globalAccountsList) {
        fetchGlobalAccounts().catch(error => {
          console.log('新标签页获取全局账号失败:', error.message);
        });
      }
    }, 1000);
  }
});

// 监听设置变化，更新冷却时间
chrome.storage.onChanged.addListener(function(changes, namespace) {
  if (namespace === 'local' && changes.signOutCooldown) {
    signOutCooldownMs = changes.signOutCooldown.newValue * 1000;
    console.log('background更新登出冷却时间:', signOutCooldownMs / 1000, '秒');
  }
  
  // 监听二维码功能设置变化
  if (namespace === 'local' && changes.enableQrCodeFeature) {
    const enabled = changes.enableQrCodeFeature.newValue;
    console.log('background检测到二维码功能设置变化:', enabled);
    
    // 向所有标签页发送切换消息
    chrome.tabs.query({}, function(tabs) {
      tabs.forEach(tab => {
        // 只向http/https页面发送消息
        if (tab.url && (tab.url.startsWith('http://') || tab.url.startsWith('https://'))) {
          chrome.tabs.sendMessage(tab.id, {
            action: 'toggleQRCode',
            enabled: enabled
          }).catch(error => {
            // 忽略无法发送消息的标签页（例如扩展页面等）
            console.log('向标签页发送二维码切换消息失败:', tab.id, error.message);
          });
        }
      });
    });
  }
});

// 监听响应以确认成功并保存登录信息
chrome.webRequest.onResponseStarted.addListener(
  function(details) {
    if (details.url.includes('/api/user/sign-in') && details.statusCode === 200) {
      console.log('登录成功，准备保存登录信息:', details);
      if (details.tabId === -1 || details.tabId === undefined) {
        console.log('登录请求不是由tab触发，跳过loginSuccess通知');
        return;
      }
      // 通知content script处理登录成功
      chrome.tabs.sendMessage(details.tabId, {
        action: 'loginSuccess',
        url: details.url,
        domain: new URL(details.url).hostname
      });
    }
  },
  {urls: ["<all_urls>"]},
  ["responseHeaders"]
);

// 监听页面开始加载，提前检查登录状态
chrome.tabs.onUpdated.addListener(function(tabId, changeInfo, tab) {
  // 在页面开始加载时就进行检查，而不是等到完成
  if ((['loading', 'complete'].includes(changeInfo.status)) && tab.url && tab.url.startsWith('http')) {
    const hostname = new URL(tab.url).hostname;
    if (hostname === 'localhost') {
      console.log('检测到localhost页面，跳过自动登录流程');
      return;
    }
    console.log('页面状态变化:', changeInfo.status, tab.url);
    if ([ '/auth/' ].some(path => tab.url.includes(path))) {
      tabLoginStatus.delete(tabId)
    }
    if (['/auth/', 'loginToken=', 'ssoToken=', 'access_token='].some(path => tab.url.includes(path))) {
      console.log('命中白名单中的url 跳过登录检查')
      return;
    }
    
    // 检查该tab是否已有登录状态且域名匹配
    const tabStatus = tabLoginStatus.get(tabId);
    if (tabStatus && tabStatus.hostname === hostname) {
      console.log(`标签页 ${tabId} 已登录，跳过检测:`, tabStatus.account.loginId);
      return;
    }
    
    // 如果域名不匹配，清除该tab的登录状态
    if (tabStatus && tabStatus.hostname !== hostname) {
      console.log(`标签页 ${tabId} 域名变化，清除登录状态:`, tabStatus.hostname, '->', hostname);
      tabLoginStatus.delete(tabId);
    }
    
    // 检查是否启用自动登录
    chrome.storage.local.get(['enableAutoLogin'], function(settings) {
      if (settings.enableAutoLogin === false) {
        console.log('自动登录已禁用');
        return;
      }

      chrome.storage.local.get([hostname], function(result) {
        if (result[hostname] && result[hostname].length > 0) {
          // 找到默认登录账号
          const defaultAccount = result[hostname].find(account => account.isDefault) || result[hostname][0];
          if (defaultAccount) {
            console.log('找到默认账号，检查登录状态:', defaultAccount);
            
            // 增加延迟，给登录状态保存足够的时间
            // 对于页面跳转的情况，给更多时间让登录状态同步
            const delay = changeInfo.status === 'loading' ? 1000 : 500;
            
            setTimeout(() => {
              // 再次检查tab状态，避免在用户刚登录后立即触发默认账号检查
              const currentTabStatus = tabLoginStatus.get(tabId);
              if (currentTabStatus && currentTabStatus.hostname === hostname) {
                console.log(`延迟检查后发现标签页 ${tabId} 已登录，跳过检测:`, currentTabStatus.account.loginId);
                return;
              }
              
              chrome.tabs.sendMessage(tabId, {
                action: 'checkLoginStatus',
                  account: defaultAccount,
                  originUrl: tab.url
                }, () => {
                  if (chrome.runtime.lastError) {
                    console.log('发送消息失败，可能因为目标是iframe或未加载完成:', chrome.runtime.lastError.message);
                  }
                });
              }, delay);
          }
        }
      });
    });
  }
});

// 清理关闭标签页的登录意图和登录状态
chrome.tabs.onRemoved.addListener((tabId) => {
  if (tabLoginStatus.has(tabId)) {
    const status = tabLoginStatus.get(tabId);
    console.log(`清理已关闭标签页 ${tabId} 的登录状态:`, status.account.loginId);
    tabLoginStatus.delete(tabId);
  }
});

// 缓存登录信息以便同步访问
let loginAccountsCache = {};
let settingsCache = { enableAutoLogin: true };

// 初始化缓存
chrome.storage.local.get(null, function(items) {
  for (const key in items) {
    if (Array.isArray(items[key])) {
      loginAccountsCache[key] = items[key];
    } else {
      settingsCache[key] = items[key];
    }
  }
  console.log('登录信息缓存已初始化:', Object.keys(loginAccountsCache));
});

// 监听存储变化，更新缓存
chrome.storage.onChanged.addListener(function(changes, namespace) {
  if (namespace === 'local') {
    for (const key in changes) {
      if (Array.isArray(changes[key].newValue)) {
        loginAccountsCache[key] = changes[key].newValue;
      } else {
        settingsCache[key] = changes[key].newValue;
      }
    }
  }
});


// 监听来自popup的消息
chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
  if (request.action === 'getLoginAccounts') {
    // 获取所有登录账号
    chrome.storage.local.get(null, function(result) {
      const accounts = [];
      for (const domain in result) {
        if (Array.isArray(result[domain])) {
          result[domain].forEach(account => {
            accounts.push({
              ...account,
            });
          });
        }
      }
      sendResponse({accounts: accounts});
    });
    return true; // 异步响应
  } else if (request.action === 'updateAccount') {
    // 更新账号信息
    const {domain, accountData} = request;
    chrome.storage.local.get([domain], function(result) {
      let accounts = result[domain] || [];
      const index = accounts.findIndex(acc => acc.loginId === accountData.loginId);
      if (index !== -1) {
        accounts[index] = accountData;
      }
      chrome.storage.local.set({[domain]: accounts}, function() {
        sendResponse({success: true});
      });
    });
    return true;
  } else if (request.action === 'deleteAccount') {
    // 删除账号
    const {hostname, domain, loginId} = request;
    chrome.storage.local.get([hostname], function(result) {
      let accounts = result[hostname] || [];
      accounts = accounts.filter(acc => !(acc.loginId === loginId && acc.hostname === hostname && acc.domain === domain));
      chrome.storage.local.set({[hostname]: accounts}, function() {
        sendResponse({success: true});
      });
    });
    return true;
  } else if (request.action === 'openTab') {
    // 新开tab页
    chrome.tabs.create({url: request.url});
    sendResponse({success: true});
  } else if (request.action === 'checkSignOutCooldown') {
    // 检查登出冷却时间
    console.log('background检查登出冷却时间:', request, '冷却时间:', signOutCooldownMs / 1000, '秒');
    
    const domain = request.domain;
    const currentTime = Date.now();
    const lastSignOutTime = lastSignOutTimeByDomain[domain] || 0;
    const timeSinceSignOut = currentTime - lastSignOutTime;
    
    // 如果冷却时间设置为0，则禁用冷却功能
    const isInCooldown = signOutCooldownMs > 0 && lastSignOutTime > 0 && timeSinceSignOut < signOutCooldownMs;
    const remainingTime = isInCooldown ? Math.ceil((signOutCooldownMs - timeSinceSignOut) / 1000) : 0;
    
    sendResponse({
      isInCooldown: isInCooldown,
      remainingTime: remainingTime,
      domain: domain,
      cooldownSetting: signOutCooldownMs / 1000
    });
  } else if (request.action === 'loginStatusChanged') {
    // 记录或清除tab的登录状态
    if (sender.tab) {
      const tabId = sender.tab.id;
      const { isLoggedIn, account, hostname, uIdToken } = request;
      if (uIdToken) {
        chrome.storage.local.get('uIdToken', function(result) {
          const existingTokens = result.uIdToken || {};
          chrome.storage.local.set({uIdToken: { ...existingTokens, [hostname]: uIdToken}}, function() {
            console.log('uIdToken已保存:', hostname, uIdToken);
          });
        })
      }

      
      if (isLoggedIn && account) {
        // 记录登录状态，保留之前的意图标记（如果有的话）
        const existingStatus = tabLoginStatus.get(tabId);
        const isIntentLogin = existingStatus && existingStatus.isIntentLogin;
        
        tabLoginStatus.set(tabId, {
          account: account,
          loginTime: Date.now(),
          hostname: hostname,
          // 如果之前是通过意图设置的，现在登录成功后移除意图标记
          isIntentLogin: false
        });
        console.log(`${isIntentLogin ? '更新' : '记录'}标签页 ${tabId} 登录状态:`, account.loginId, '域名:', hostname);
      } else {
        // 清除登录状态
        if (tabLoginStatus.has(tabId)) {
          const status = tabLoginStatus.get(tabId);
          console.log(`清除标签页 ${tabId} 登录状态:`, status.account.loginId);
          tabLoginStatus.delete(tabId);
        }
      }
    }
    sendResponse({success: true});
  } else if (request.action === 'getCurrentTabLoginStatus') {
    // 获取当前tab的登录状态
    if (sender.tab) {
      const tabId = sender.tab.id;
      const tabStatus = tabLoginStatus.get(tabId);
      console.log(`获取标签页 ${tabId} 登录状态:`, tabStatus);
      
      if (tabStatus) {
        sendResponse({
          success: true,
          account: tabStatus.account,
          loginTime: tabStatus.loginTime,
          hostname: tabStatus.hostname
        });
      } else {
        sendResponse({
          success: false,
          account: null
        });
      }
    } else {
      sendResponse({
        success: false,
        account: null
      });
    }
  } else if (request.action === 'openAndLogin') {
    const account = request.account;
    if (account && (account.origin || account.hostname)) {
      const origin = account.origin || `https://${account.hostname}`;
      const loginUrl = `${origin}/api/user/sign-in`;
      
      // 构造登录请求体
      const loginData = {
        loginId: account.loginId,
        password: account.password,
        domain: account.domain
      };
      
      console.log('尝试获取登录token:', loginUrl, account.loginId);
      
      // 发送登录请求获取token
      fetch(loginUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(loginData)
      })
      .then(response => {
        if (!response.ok) {
          throw new Error(`登录请求失败: ${response.status}`);
        }
        return response.json();
      })
      .then(data => {
        console.log('登录响应:', data);
        
        // 从响应中提取token（根据实际API响应格式调整）
        const token = data.uIdToken;
        
                 if (token) {
           // 打开带有token的新标签页
           const urlWithToken = `${origin}?loginToken=${token}`;
           chrome.tabs.create({ url: urlWithToken, active: true }, (tab) => {
             // 直接设置该标签页的登录状态，避免后续自动登录检查
             tabLoginStatus.set(tab.id, {
               account: account,
               loginTime: Date.now(),
               hostname: account.hostname,
               isIntentLogin: false // 已经完成登录，不是意图状态
             });
             console.log(`打开带token的页面: ${urlWithToken}`);
             console.log(`标签页 ${tab.id} 登录状态已设置:`, account.loginId);
             sendResponse({ success: true, token: token });
           });
         } else {
          console.error('响应中未找到token');
          sendResponse({ success: false, message: '登录成功但未获取到token' });
        }
      })
      .catch(error => {
        console.error('登录请求失败:', error);
        sendResponse({ success: false, message: `登录失败: ${error.message}` });
      });
    } else {
      sendResponse({ success: false, message: '无效的账号信息（缺少origin和hostname）' });
    }
    return true; // 异步响应
  } else if (request.action === 'signOutDetected') {
    // 记录登出时间并清除tab登录状态
    console.log('background收到登出通知:', request);
    const domain = request.domain;
    lastSignOutTimeByDomain[domain] = Date.now();
    console.log('background设置登出时间:', new Date(lastSignOutTimeByDomain[domain]).toLocaleTimeString(), '域名:', domain);
    
    // 清除对应tab的登录状态
    if (sender.tab && tabLoginStatus.has(sender.tab.id)) {
      const tabId = sender.tab.id;
      const status = tabLoginStatus.get(tabId);
      console.log(`清理登出标签页 ${tabId} 的登录状态:`, status.account.loginId);
      tabLoginStatus.delete(tabId);
    }
    
    sendResponse({success: true});
  } else if (request.action === 'refreshGlobalAccounts') {
    // 刷新全局账号列表
    console.log('收到刷新全局账号列表请求');
    fetchGlobalAccounts().then(() => {
      sendResponse({
        success: !!globalAccountsList,
        data: globalAccountsList,
        message: globalAccountsList ? '刷新成功' : '刷新失败'
      });
    }).catch((error) => {
      console.log('刷新全局账号列表失败:', error);
      sendResponse({
        success: false,
        data: null,
        message: error.message || '网络请求失败'
      });
    });
    return true; // 异步响应
  } else if (request.action === 'getGlobalAccounts') {
    // 获取全局账号列表（只从内存缓存中获取）
    if (globalAccountsList) {
      sendResponse({
        success: true,
        data: globalAccountsList
      });
    } else {
      // 如果内存中没有，尝试重新获取
      fetchGlobalAccounts().then(() => {
        sendResponse({
          success: !!globalAccountsList,
          data: globalAccountsList
        });
      }).catch((error) => {
        console.log('重新获取全局账号列表失败:', error);
        sendResponse({
          success: false,
          data: null
        });
      });
      return true; // 异步响应
    }
  }
}); 
